package com.dns.test.client.sender;

import java.net.SocketException;

import com.dns.message.DNS_Message;
import com.dns.util.Constants;


public class MessageSenderThread extends Thread{
	
	public void run(int startMsgIndex, int endMsgIndex, int scenarioId) throws SocketException
	{
		
		if(scenarioId <= DNSClient.scenarios)
		{
			runScenarios(startMsgIndex, endMsgIndex, scenarioId);
			return;
		}
			
		
		for(int index = startMsgIndex; index <= endMsgIndex; ++index)
		{
			DNS_Message msg=null;
			
			String ip = DNSMessages.Msgs[index][0];
			int port = Integer.parseInt(DNSMessages.Msgs[index][1]);
			
			String dnsType = DNSMessages.Msgs[index][3];
			
			if( (dnsType.equals("DNS") || dnsType.equals("REVERSE_DNS")))
			{
				msg = sendMessageToPrimaryServer(DNSMessages.Msgs[index]);
			}
			else
			{
				msg = sendMessageToSecondaryServer(DNSMessages.Msgs[index]);
			}
			DNSClient.sendMessage(ip, port, msg);
		}
		
		//System.out.println("Thread done with sending requests\n");
	}
	
	private void runScenarios(int startMsgIndex, int endMsgIndex, int scenarioId) throws SocketException
	{
		if(1 == scenarioId)
			scenario_1(startMsgIndex, endMsgIndex);
		if(2 == scenarioId)
			scenario_2(startMsgIndex, endMsgIndex);
		if(3 == scenarioId)
			scenario_3(startMsgIndex, endMsgIndex);
		if(4 == scenarioId)
			scenario_4(startMsgIndex, endMsgIndex);		
	}
	
	private void scenario_1(int startMsgIndex, int endMsgIndex) throws SocketException
	{
		for(int index = startMsgIndex; index <= endMsgIndex; ++index)
		{
			DNS_Message msg=null;
			
			String ip = DNSMessages.Scenario_1[index][0];
			int port = Integer.parseInt(DNSMessages.Scenario_1[index][1]);
			
			String dnsType = DNSMessages.Scenario_1[index][3];
			
			if( (dnsType.equals("DNS") || dnsType.equals("REVERSE_DNS")))
			{
				msg = sendMessageToPrimaryServer(DNSMessages.Scenario_1[index]);
			}
			else
			{
				msg = sendMessageToSecondaryServer(DNSMessages.Scenario_1[index]);
			}
			DNSClient.sendMessage(ip, port, msg);
		}		
	}

	private void scenario_2(int startMsgIndex, int endMsgIndex) throws SocketException
	{
		for(int index = startMsgIndex; index <= endMsgIndex; ++index)
		{
			DNS_Message msg=null;
			
			String ip = DNSMessages.Scenario_2[index][0];
			int port = Integer.parseInt(DNSMessages.Scenario_2[index][1]);
			
			String dnsType = DNSMessages.Scenario_2[index][3];
			
			if( (dnsType.equals("DNS") || dnsType.equals("REVERSE_DNS")))
			{
				msg = sendMessageToPrimaryServer(DNSMessages.Scenario_2[index]);
			}
			else
			{
				msg = sendMessageToSecondaryServer(DNSMessages.Scenario_2[index]);
			}
			DNSClient.sendMessage(ip, port, msg);
		}		
	}

	private void scenario_3(int startMsgIndex, int endMsgIndex) throws SocketException
	{
		for(int index = startMsgIndex; index <= endMsgIndex; ++index)
		{
			DNS_Message msg=null;
			
			String ip = DNSMessages.Scenario_3[index][0];
			int port = Integer.parseInt(DNSMessages.Scenario_3[index][1]);
			
			String dnsType = DNSMessages.Scenario_3[index][3];
			
			if( (dnsType.equals("DNS") || dnsType.equals("REVERSE_DNS")))
			{
				msg = sendMessageToPrimaryServer(DNSMessages.Scenario_3[index]);
			}
			else
			{
				msg = sendMessageToSecondaryServer(DNSMessages.Scenario_3[index]);
			}
			DNSClient.sendMessage(ip, port, msg);
		}		
	}

	private void scenario_4(int startMsgIndex, int endMsgIndex) throws SocketException
	{
		for(int index = startMsgIndex; index <= endMsgIndex; ++index)
		{
			DNS_Message msg=null;
			
			String ip = DNSMessages.Scenario_4[index][0];
			int port = Integer.parseInt(DNSMessages.Scenario_4[index][1]);
			
			String dnsType = DNSMessages.Scenario_4[index][3];
			
			if( (dnsType.equals("DNS") || dnsType.equals("REVERSE_DNS")))
			{
				msg = sendMessageToPrimaryServer(DNSMessages.Scenario_4[index]);
			}
			else
			{
				msg = sendMessageToSecondaryServer(DNSMessages.Scenario_4[index]);
			}
			DNSClient.sendMessage(ip, port, msg);
		}		
	}
	
	private DNS_Message sendMessageToPrimaryServer(String args[]) throws SocketException
	{
		String queryType = args[3];
		
		if(queryType.equals("DNS"))
			return sendDnsRequest(args);
		else
			return reverseDNS(args);			
	}
	
	private DNS_Message sendMessageToSecondaryServer(String args[]) throws SocketException
	{
		return update(args);
	}
	
	private void setClientInfo(DNS_Message msg)
	{
		msg.setClientAddress(DNSClient.clientIP);
		msg.setClientPort(DNSClient.clientPort);		
	}
	
	private DNS_Message sendDnsRequest(String args[]) throws SocketException
	{	
		System.out.println("Sending DNS Request:");
		String domain = args[4];
		DNS_Message msg = new DNS_Message();
		setClientInfo(msg);
		msg.setSource(Constants.CLIENT);
		msg.setMsgType(Constants.MSG_INQUIRY);
		msg.setDomainName(domain);
		//System.out.println("Domain - "+domain);
		return msg;
	}

	private DNS_Message reverseDNS(String args[]) throws SocketException
	{
		System.out.println("Sending REVERSE DNS Request:");
		String ip = args[4];
		DNS_Message msg = new DNS_Message();
		setClientInfo(msg);
		msg.setSource(Constants.CLIENT);
		msg.setMsgType(Constants.MSG_INQUIRY);
		msg.setIp_address(ip);		
		return msg;		
	}

	private DNS_Message update(String args[]) throws SocketException
	{
		System.out.println("Sending UPDATE Request:");
		String domain = args[3];
		String ip = args[4];
		DNS_Message msg = new DNS_Message();
		setClientInfo(msg);
		msg.setSource(Constants.CLIENT);
		msg.setMsgType(Constants.MSG_UPDATE);
		msg.setIp_address(ip);
		msg.setDomainName(domain);
		msg.setTtl(6000);
		return msg;	
	}
}
